| iOS 4 in Action
Developing iPhone & iPad Apps
By Jocelyn Harrington, Brandon Trebitowski, Christopher Allen, and Shannon Appelcline
Though multicore is not available on iOS devices, Grand Central Dispatch helps the application to run faster, more efficiently, and asynchronously. In this article, based on chapter 16 of iOS 4 in Action, the authors show you how GCD is used to fetch events.
To save 35% on your next purchase use Promotional Code jharrington1635 when you check out at www.manning.com.
You may also be interested in…
|
Grand Central Dispatch (GCD) was available on Mac OS as comprehensive
improvements to support concurrent code execution on multicore hardware
technology. Now, it’s available on iOS 4 as a C API. Though multicore is not
available on iOS devices, GCD helps the application to run faster, more
efficiently, and asynchronously. You can find more reference on Concurrency
Programming Guide from the iOS developer website. Let’s look at GCD and use it
to fetch events.
How does it work?
GCD is available to any application and there is no need to add
in any other framework. You can imagine that you have queues of operations and
each queue is running in its own thread separately by the system. You don’t
have to worry about when to run the time-consuming operations. The system will
take care of the order and make sure that the queue’s operations get done.
In order to keep the application running responsively, the key
concept is not to block the main thread. Throw a time-consuming task, such as
fetching a list of events from the Calendar’s database or downloading an image
file from the Internet, to the background thread. Then, update the UI after the
work in the background is done, and the data is ready to display.
How do you accomplish this task with GCD? It turns out, it’s
pretty easy. Simply, call the method dispatch_async()
to submit a queue of
operations (a block of code) to the main queue and execute the task on a
dispatch queue asynchronously, and then tell the system to update the UI.
The definition for dispatch_async() is listed as:
void dispatch_async( dispatch_queue_t queue,
dispatch_block_t block
);
How do we create a queue or get the main queue? Here are some
common methods related to GCD:
- Creating a queue:
dispatch_queue_t
dispatch_queue_create(const char *label, NULL);
- Releasing a queue:
void
dispatch_release(dispatch_queue_t);
- Getting the main
queue:
dispatch_queue_t
dispatch_get_main_queue();
Please don’t forget to release the queue when it is created with method
dispatch_queue_create()
.
With GCD and blocks in hand, let’s see how to create a queue for
the fetching events operations and let the system decide when to run this
queue, and then update the UI in the main thread.
Fetching Events with GCD
Let’s use the GCD and blocks to fetch the
whole month of events and update the table view display.
Listing 1 Fetching events with GCD
-(void)fetchEventsForNextMonth {
NSDate *startDate = [NSDate date];
NSDate *endDate = [NSDate dateWithTimeIntervalSinceNow:60*60*24*30];
NSPredicate *predicate = [self.eventStore predicateForEventsWithStartDate:startDate endDate:endDate calendars:eventStore.calendars];
dispatch_queue_t fetching_queue=
dispatch_queue_create("Fetching events", NULL);#1
dispatch_async(fetching_queue, ^{ #2
NSArray *eventList =
[self.eventStore eventsMatchingPredicate:predicate];
dispatch_async(dispatch_get_main_queue(), ^{ #3
[self.events addObjectsFromArray:eventList];
[self.tableView reloadData];
});
});
dispatch_release(fetching_queue); #4
}
#1 Defines a custom queue
#2 Fetches events
#3 Updates UI
#4 Releases queue
In listing 1, we first create a custom queue (#1). The GCD
function starts (#2). The block of operations will first execute the custom
task to fetch events from the Calendar’s database on the dispatch queue. When
the eventList
array is ready, we want to update the table view’s UI with the new data on the
main queue dispatch. The block (#3) first updates the events array and then reloads the table
view’s data. Finally, don’t forget to release the queue (#4). Simply follow the
design flow; GCD will automatically finish the task and provide a quick
response asynchronously.
As you can see from the example, with a few lines of code, you
managed to perform a task in the background and update the UI when the new data
is ready. That’s the power of GCD and blocks.
Summary
The Event Kit framework provides an interface for accessing
calendar events on a user’s device. You can use this framework to get existing
events and add new events to the user’s calendar. With GCD, the application’s
performance is improved significantly, especially when fetching events from
Calendar’s database asynchronously.
Here are
some other Manning titles you might be interested in: